Please make this a struct rather than a tuple with explanatory comments and const indices.

Or, better for this purpose, don't use parameterized testing for this at all - it's much clearer to just have member variables in the test class, so instead of something like

TEST_P(OutlierDetectionIntegrationTest, TestEverything) {
  auto x = GetParam(1).x;
  auto y = GetParam(1).y;
  auto foo = initializeXY(x, y);
  auto expected = GetParam(1).expected;
  EXPECT_THAT(doStuff(foo), Eq(expected));
}

INSTANTIATE_TEST_SUITE_P(
  TestArgStruct{"1And2ResultsIn3", 1, 2, 3},
  TestArgStruct{"4And5ResultsIn9", 4, 5, 9},
);

you just do

TEST_F(OutlierDetectionIntegrationTest, Test1and2ResultsIn3) {
  auto foo = initializeXY(1, 2);
  EXPECT_THAT(doStuff(foo), Eq(3));
}

TEST_F(OutlierDetectionIntegrationTest, Test4and5ResultsIn9) {
  auto foo = initializeXY(4, 5);
  EXPECT_THAT(doStuff(foo), Eq(9));
}

Even though if there are many tests this may result in more lines (it typically doesn't actually because the fields usually end up one line each, and passing the same values into helper functions is also usually one line), it makes for test code that's dramatically easier to read and understand, and you don't need to include special stringification functions and struct/tuple definitions etc.

Helper functions in the test class, member variables in the test class for persistent stuff, and custom matchers, will typically be fewer lines overall than a monolithic "do all the same stuff with different inputs" function - you can still put all the repetitive stuff inside helper functions.

In general if you use TEST_P with only one test, you shouldn't be using TEST_P - it's useful for the combinatorial thing where you want to run multiple tests with a range of configuration states.

@ravenblackx Thanks for reviewing. I think you have very good points here. What bothered me was the amount of repeated code and I was under the impression that the best way to solve them was using parameterized tests. But your point that it is difficult to read such tests is a very valid one! Especially, when COMBINE is used to built a matrix of parameters.
I am going to close this PR and refactor my tests to use helper functions (as you suggest), which should be much cleaner and easier to understand.

One more minor suggestion that may or may not help - sometimes a good thing to do is subclass a test class with some common initialization, so you can have a "generic" test class you use for awkward cases, where you call the helper functions explicitly, and the "common" test class where all the initialization and teardown helpers are called with default args in the SetUp/TearDown/constructor/destructor of the class and you just do the one differing part explicitly.
(But also sometimes it may be clearer to just always explicitly call the helpers, or use a short version of the helpers like defaultInitialize().)

The subclass thing is especially likely to be useful in integration tests because there sometimes the integration test superclass performs some initialization, so you have to prepare different setup stuff during the constructor or SetUp function, via an overridden virtual function.

The subclass thing is especially likely to be useful in integration tests because there sometimes the integration test superclass performs some initialization, so you have to prepare different setup stuff during the constructor or SetUp function, via an overridden virtual function.

This is a great point. I will try to refactor the same tests I tried to parameterize in this PR and will see where special initialization is needed.